package GUI;

import Applikationslogik.Alarm;
import Applikationslogik.Kalender;
import Applikationslogik.Kalendereintrag;
import Applikationslogik.Kategorie;
import Applikationslogik.KategorieImpl;
import Applikationslogik.Person;
import Applikationslogik.Verwaltung;
import java.awt.BorderLayout;
import java.awt.EventQueue;

import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;
import java.awt.Dimension;
import javax.swing.JLabel;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.net.MalformedURLException;
import java.rmi.Naming;
import java.rmi.NotBoundException;
import java.rmi.RemoteException;
import java.sql.Timestamp;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.Vector;
import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JOptionPane;
import javax.swing.JScrollBar;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;


/**
 * Hauptpanel Reporter
 * @author Rene
 */
public class GUIReporter extends JFrame {

        Person eingeloggte_person;
        Verwaltung v = null;
        private HashMap<String, Person> person;
        private HashMap<String, Kalender> kalender;
        private HashMap<String, Kategorie> kategorie;
        private Vector <Person> unsere_personen;
        private Vector <Kalender> unsere_kalender;
        private Vector <Kategorie> unsere_kategorie;
        private Vector <Kalendereintrag> ergebnis;
        private Vector <Alarm> unsere_alarme;
	private JPanel panel_Hintergrund;
        private JPanel panel_Reporter;
        private JScrollPane bar_scroll;

        private Date start_date_1;
        private Date end_date_1;

        private JButton button_ausgabe;

        private JComboBox combobox_kalenderwahl;
        private JComboBox combobox_kategoriewahl;
        private JComboBox combobox_personenwahl;

        private JTextField textfield_startdatum;
        private JTextField textfield_enddatum;

        private JComboBox combobox_startzeit;
        private JComboBox combobox_endzeit;

        private JComboBox combobox_startzeit2;
        private JComboBox combobox_endzeit2;

        private JButton button_startdatum;
        private JButton button_enddatum;

        private JLabel label_ueberschrift;
        private JLabel label_personenauswahl;
        private JLabel label_ausgabe;



	private JLabel label_KalenderWaehlen;
        private JTextField textField_KalenderWahl;

        private JLabel label_KategorieWaehlen;
        private JTextField textField_KategorieWahl;

       	private JLabel label_StartuhrzeitWahl;
        private JLabel label_StartuhrzeitStunden;
        private JTextField textField__StartuhrzeitStunden;
        private JLabel label_StartuhrzeitMinuten;
        private JTextField textField__StartuhrzeitMinuten;

        private JLabel label_EnduhrzeitWahl;
        private JLabel label_EnduhrzeitStunden;
        private JTextField textField_EnduhrzeitStunden;
        private JLabel label_EnduhrzeitMinuten;
        private JTextField textField_EnduhrzeitMinuten;
        private JTextField textField_startdatum;

        private JLabel label_ZeitraumBestimmen;

        private JLabel label_StartDatum;
        private JTextField textField_Startdatum;
        private JLabel label_EndDatum;
        private JTextField textField_Enddatum;

	private JTextArea textArea_Ausgabe;

	private Bestaetigung best_EintragLoeschen;


        /**
         *
         * @param args
         */
        public static void main(String[] args) {
		EventQueue.invokeLater(new Runnable() {
			public void run() {
				try {
					GUIReporter frame = new GUIReporter();
					frame.setVisible(true);
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		});
	}



        /**
         *
         */
        public GUIReporter() {
		// Fenstereigenschaften setzen

		setTitle("GruppenKalender");
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setBounds(100, 100, 800, 600);
		setResizable(false);

		Login dialog_Login = new Login();

                Vector <Person> unsere_personen = new Vector();


                // Wir lesen alle Personen aus und schreiben diese in einen neuen Vektor
                 try {
                     // Wir lesen alle Personen aus
                     v = getVerwaltung();
                     unsere_personen = v.getAllPerson();

                 } catch (RemoteException re) {

                 }

                //Hashmap für die ComboBox wird erstellt
                person = new HashMap<String,Person>();
                for (int i = 0; i < unsere_personen.size(); i++) {
                    try {
                        person.put(unsere_personen.elementAt(i).get_voller_name(), unsere_personen.elementAt(i));
                    } catch (RemoteException ex) {
                    }
                }

		//Hier kriegne wir das Person Objekt zurück mit welchem sich der Nutzer im Login angemeldet hat
                eingeloggte_person = dialog_Login.ermittleLoginUser(person);


		//Panels initialisieren
		initPanels();

		// Hintergrundspanel einrichten


		panel_Hintergrund = new JPanel();
		panel_Hintergrund.setPreferredSize(new Dimension(800, 600));
		panel_Hintergrund.setBounds(100, 0, 800, 600);
		panel_Hintergrund.setBorder(new EmptyBorder(5, 5, 5, 5));
		setContentPane(panel_Hintergrund);
		panel_Hintergrund.setLayout(new BorderLayout());

                zeichnePanelReporter();

        }

        /**
         *
         * @return
         */
        public Verwaltung getVerwaltung(){
                // Wir lesen die IP aus einer Textdatei
                    FileReader fr = null;
                    try {
                        fr = new FileReader("config.txt");
                    } catch (FileNotFoundException ex) {
                        Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                    }
                    BufferedReader br = new BufferedReader(fr);

                    String zeile1 = null;
                    try {
                        zeile1 = br.readLine();
                    } catch (IOException ex) {
                        Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                    }
                    System.out.println("GUI verbindet zu: " + zeile1);


               try {
                    v = (Verwaltung)Naming.lookup(zeile1);
                    System.out.println("Verbunden, Verwaltungsobjekt erhalten");

                } catch (MalformedURLException murle) {
                    System.out.println(murle);
                } catch (RemoteException re) {
                    System.out.println(re);
                } catch (NotBoundException nbe) {
                    System.out.println(nbe);
                }
                return this.v;
            }

        private void versteckePanels() {
                    //panel_Hintergrund.setVisible(false);
                    panel_Reporter.setVisible(false);
                }

	// Methoden, die die einzelnen panels anzeigen lassen
	private void zeichnePanelReporter(){
		versteckePanels();

                // Alarme werden abgerufen
                unsere_alarme = new Vector();
                    try {
                        unsere_alarme = v.findall_alarm_by_person(eingeloggte_person.get_person_id());
                    } catch (RemoteException ex) {
                    }

                // Nun wird pro Alarm die Klasse AlarmPopUp ausgeführt, dort wird pro Alarm ein Thread erzeugt der überprüft ob die Systemzeit == Alarmzeit ist, falls ja kommt ein PopUp
                for (int i=0 ;i < unsere_alarme.size() ; i++)
                {
                        try {

                            Timestamp y = unsere_alarme.get(i).get_zeitpunkt();
                            String z = unsere_alarme.get(i).get_bezeichnung();

                            //Konvertierung des Timestamps zu long

                            long time = y.getTime();

                            AlarmPopUp x = new AlarmPopUp(time, z);
                           
                            System.out.println("Zeit via Long:" + time);
                            x.start();





                            
                            

                        } catch (RemoteException ex) {
                        }
                }

                unsere_personen = new Vector();
                unsere_kalender = new Vector();
                unsere_kategorie = new Vector();

                // Wir lesen alle Personen aus und schreiben diese in einen neuen Vektor
                 try {
                     // Wir lesen alle Personen aus
                     v = getVerwaltung();
                     unsere_personen = v.getAllPerson();
                     unsere_kategorie = v.get_all_Kategorie();

                 } catch (RemoteException re) {

                 }

                //Hashmap für die ComboBox Personen wird erstellt
                person = new HashMap<String,Person>();
                for (int i = 0; i < unsere_personen.size(); i++) {
                    try {
                        person.put(unsere_personen.elementAt(i).get_voller_name(), unsere_personen.elementAt(i));
                    } catch (RemoteException ex) {
                    }
                }

                //Hashmap für die ComboBox Kategorien wird erstellt
                kategorie = new HashMap<String,Kategorie>();
                

                 //Der Kategoriewahl wir noch der Eintrag <alle> hinzugefügt
                    String alle = "<alle>";

                        try {
                            // Es wird eine "Fake" Kategorie angelegt mit der Bezeichnung alle // Quick'n Dirty Fix ;)
                            Kategorie alle_kategorie = new KategorieImpl();
                            alle_kategorie.set_name("<alle>");
                            alle_kategorie.set_kategorie_id(9999999);
                            kategorie.put(alle, alle_kategorie);
                        } catch (RemoteException ex) {
                            Logger.getLogger(GUIReporter.class.getName()).log(Level.SEVERE, null, ex);
                        }

                    for (int i = 0; i < unsere_kategorie.size(); i++) {
                    try {
                        kategorie.put(unsere_kategorie.elementAt(i).get_name(), unsere_kategorie.elementAt(i));

                    } catch (RemoteException ex) {
                    }

                    }


		panel_Hintergrund.removeAll();
		panel_Reporter = new JPanel();
		panel_Hintergrund.add(panel_Reporter, BorderLayout.CENTER);
		panel_Reporter.setLayout(null);

                label_ueberschrift = new JLabel ("<html><u>Reporter</u></html>");
                label_ueberschrift.setFont(new Font("Tahoma", Font.PLAIN, 15));
                label_ueberschrift.setBounds(50, 35, 220, 30);
                panel_Reporter.add(label_ueberschrift);

		JLabel label_KalenderWahl = new JLabel("Kalenderauswahl");
		label_KalenderWahl.setBounds(50, 125, 130, 30);
		panel_Reporter.add(label_KalenderWahl);

                combobox_kalenderwahl = new JComboBox();
                combobox_kalenderwahl.setBounds(210, 130, 250, 20);
                panel_Reporter.add(combobox_kalenderwahl);

                combobox_personenwahl = new JComboBox();
                combobox_personenwahl.setBounds(210, 90, 250, 20);
                panel_Reporter.add(combobox_personenwahl);
                combobox_personenwahl.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e)
                    {
                            combobox_kalenderwahl.removeAllItems();
                            try {
                                unsere_kalender = v.get_kalender_reporter(eingeloggte_person, person.get(combobox_personenwahl.getSelectedItem()));
                            } catch (RemoteException ex) {
                                Logger.getLogger(GUIReporter.class.getName()).log(Level.SEVERE, null, ex);
                            }

                            //Hashmap für die ComboBox wird erstellt
                            kalender = new HashMap<String, Kalender>();
                            for (int i = 0; i < unsere_kalender.size(); i++) {
                                try {
                                    kalender.put(unsere_kalender.elementAt(i).get_bezeichnung(), unsere_kalender.elementAt(i));
                                } catch (RemoteException ex) {
                                }
                            }
                            for (String key : kalender.keySet()) {
                            combobox_kalenderwahl.addItem(key);
                }
                     }


                });

                //Befüllen der Personen ComboBox mit Einträgen der HashMap
                for (String key : person.keySet()) {
                    combobox_personenwahl.addItem(key);
                }



                JLabel label_KategorieWahl = new JLabel("Kategorie wählen");
		label_KategorieWahl.setBounds(50, 170, 130, 30);
		panel_Reporter.add(label_KategorieWahl);

                combobox_kategoriewahl = new JComboBox();
                combobox_kategoriewahl.setBounds(210, 170, 250, 20);
                panel_Reporter.add(combobox_kategoriewahl);

                // Befüllen der ComboBox Kategoriewahl mit Kategorieeinträgen
                for (String key : kategorie.keySet()) {
                    combobox_kategoriewahl.addItem(key);
                }

                label_personenauswahl = new JLabel("Person wählen");
		label_personenauswahl.setBounds(50, 85, 220, 30);
		panel_Reporter.add(label_personenauswahl);

                JLabel label_Datum = new JLabel("Startdatum auswählen:");
                label_Datum.setBounds(50, 215, 170, 30);
                panel_Reporter.add(label_Datum);

                textField_startdatum = new JTextField();
                textField_startdatum.enableInputMethods(true);
                textField_startdatum.setEditable(false);
                textField_startdatum.setBounds(210, 220, 80, 20);
                panel_Reporter.add(textField_startdatum);

                final JFrame f = new JFrame();

                f.setTitle("Startdatum auswählen");

                f.pack();
                f.setVisible(false);

                button_startdatum = new JButton("Kalender öffnen");
                button_startdatum.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent e) {
                            textField_startdatum.setText(new DatePicker(f).setPickedDate());
                        }
                });
                button_startdatum.setBounds(300, 220, 130, 20);
                panel_Reporter.add(button_startdatum);

                JLabel label_startuhrzeit = new JLabel("Startzeit wählen:");
                label_startuhrzeit.setBounds(450, 215, 170, 30);
                panel_Reporter.add(label_startuhrzeit);



                combobox_startzeit = new JComboBox();
                combobox_startzeit.setBounds(560, 220, 50, 20);
                panel_Reporter.add(combobox_startzeit);
                for(int i=0; i<24; i++)
                {
                    // Für 2 stellige Ausgabe in der ComboBox, wichtig auch zum parsen des Datums z.B. 1 -> 01
                    String zahl = String.format("%02d", i);
                    combobox_startzeit.addItem(zahl);
                }


                combobox_endzeit = new JComboBox();
                combobox_endzeit.setBounds(620, 220, 50, 20);
                panel_Reporter.add(combobox_endzeit);

                for(int i=0; i<60; i++)
                {
                     // Für 2 stellige Ausgabe in der ComboBox, wichtig auch zum parsen des Datums z.B. 1 -> 01
                    String zahl = String.format("%02d", i);
                    combobox_endzeit.addItem(zahl);
                }


                label_EnduhrzeitWahl = new JLabel("Enddatum auswählen:");
                label_EnduhrzeitWahl.setBounds(50, 245, 170, 30);
                panel_Reporter.add(label_EnduhrzeitWahl);

                textfield_enddatum = new JTextField();
                textfield_enddatum.enableInputMethods(true);
                textfield_enddatum.setEditable(false);
                textfield_enddatum.setBounds(210, 250, 80, 20);
                panel_Reporter.add(textfield_enddatum);

                final JFrame f2 = new JFrame();

                f2.setTitle("Startdatum auswählen");

                f2.pack();
                f2.setVisible(false);

                button_enddatum = new JButton("Kalender öffnen");
                button_enddatum.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent e) {
                            textfield_enddatum.setText(new DatePicker(f2).setPickedDate());
                        }
                });
                button_enddatum.setBounds(300, 250, 130, 20);
                panel_Reporter.add(button_enddatum);

                label_EnduhrzeitWahl = new JLabel("Endzeit wählen:");
                label_EnduhrzeitWahl.setBounds(450, 250, 170, 30);
                panel_Reporter.add(label_EnduhrzeitWahl);



                combobox_startzeit2 = new JComboBox();
                combobox_startzeit2.setBounds(560, 250, 50, 20);
                panel_Reporter.add(combobox_startzeit2);
                for(int i=0; i<=23; i++)
                {
                     // Für 2 stellige Ausgabe in der ComboBox, wichtig auch zum parsen des Datums z.B. 1 -> 01
                    String zahl = String.format("%02d", i);
                    combobox_startzeit2.addItem(zahl);
                }


                combobox_endzeit2 = new JComboBox();
                combobox_endzeit2.setBounds(620, 250, 50, 20);
                panel_Reporter.add(combobox_endzeit2);

                for(int i=0; i<=59; i++)
                {
                     // Für 2 stellige Ausgabe in der ComboBox, wichtig auch zum parsen des Datums z.B. 1 -> 01
                    String zahl = String.format("%02d", i);
                    combobox_endzeit2.addItem(zahl);
                }


                button_ausgabe = new JButton("<html><u>Ausgabe</u></html>");
                button_ausgabe.addActionListener(new ActionListener() {
                        public void actionPerformed(ActionEvent e) {
                         // Es wird überprüft ob alle notwendigen Felder ausgefüllt wurden, falls nicht, wird ein PopUp angezeigt und der Eintrag wird nicht an die Verwaltung übergeben
                        if (textField_startdatum.getText().equals("") || textfield_enddatum.getText().equals("")) {
                            JOptionPane.showMessageDialog(panel_Reporter, "Bitte START sowie END Datum angeben");   }
                        else {

                            // 1. StartDatum auslesen, parsen und als Timestamp abspeichern

                                // String mit allen Angaben des Startdatums bauen
                                String volles_Datum_start = textField_startdatum.getText() + " " + combobox_startzeit.getSelectedItem() + ":" + combobox_endzeit.getSelectedItem();
                                String volles_Datum_end = textfield_enddatum.getText() + " " + combobox_startzeit2.getSelectedItem() + ":" + combobox_endzeit2.getSelectedItem();

                               // String wird via SimpleDateFormat geparst, da es zu Fehlern kommen kann mit try/catch Block abgefangen
                               SimpleDateFormat start_date = new SimpleDateFormat("dd-MM-yyyy HH:mm");
                               SimpleDateFormat end_date = new SimpleDateFormat("dd-MM-yyyy HH:mm");

                                    try {
                                        start_date_1 = start_date.parse(volles_Datum_start);
                                        end_date_1 = end_date.parse(volles_Datum_end);
                                    } catch (ParseException ex) {
                                        Logger.getLogger(GUI.class.getName()).log(Level.SEVERE, null, ex);
                                    }

                               // SimpleDateFormat wird in GregorianCalendar konvertiert und daraus dann ein Timestamp erzeugt

                                    Calendar cal_start = Calendar.getInstance();
                                    cal_start.setTime(start_date_1);                    // Startzeitpunkt
                                    cal_start.set(Calendar.MILLISECOND, 0);
                                    Timestamp sta = new Timestamp(cal_start.getTimeInMillis());

                                    Calendar cal_ende = Calendar.getInstance();
                                    cal_ende.setTime(end_date_1);                    // Startzeitpunkt
                                    cal_ende.set(Calendar.MILLISECOND, 0);
                                    Timestamp end = new Timestamp(cal_ende.getTimeInMillis());

                                    System.out.println(sta + "   " + end);

                                // Abschicken der Abfrage an die Verwaltung und abspeichern des Ergebnisses in einen Vector (Vector referenziert auf die Kalendereinträge)

                                 ergebnis = new Vector();
                                    try {
                                        ergebnis = v.ausgabe_reporter(kalender.get(combobox_kalenderwahl.getSelectedItem()), kategorie.get(combobox_kategoriewahl.getSelectedItem()), sta, end);
                                    } catch (RemoteException ex) {
                                        Logger.getLogger(GUIReporter.class.getName()).log(Level.SEVERE, null, ex);
                                    }

                                 // String in der das Ergebnis gebaut wird
                                 textArea_Ausgabe.setText("");
                                 String finale_ausgabe = "";

                                 System.out.println(ergebnis.size());

                                 for(int f=0;f<ergebnis.size();f++)
                                 {
                                        try {
                                            finale_ausgabe = finale_ausgabe + ergebnis.elementAt(f).get_beschreibung() + " /// " + ergebnis.elementAt(f).get_start() + " bis " + ergebnis.elementAt(f).get_ende() + " /// " + ergebnis.elementAt(f).get_ort() + "\n";
                                        } catch (RemoteException ex) {
                                            Logger.getLogger(GUIReporter.class.getName()).log(Level.SEVERE, null, ex);
                                        }
                                 }

                                 textArea_Ausgabe.setText(finale_ausgabe);

                        }
                        }
                });
                button_ausgabe.setBounds(50, 300, 100, 20);
                panel_Reporter.add(button_ausgabe);

                //JTextField mit Scrollbar
		textArea_Ausgabe = new JTextArea();
		textArea_Ausgabe.setBounds(50, 330, 600, 220);
                bar_scroll = new JScrollPane(textArea_Ausgabe);
                bar_scroll.setBounds(50, 330, 600, 220);
                panel_Reporter.add (bar_scroll);
                textArea_Ausgabe.setEditable(false);


        }


	private void initPanels(){
		panel_Hintergrund = new JPanel();
		panel_Reporter = new JPanel();
        }

}
        